/**
 *  http请求工具
 *  author: JackieQ
 *  date: 2018/9/27
 */
var BASE_URL = 'http://192.168.0.88:8031';   //本地测试
var ADMIN_ID = localStorage.getItem("userId");
// var BASE_URL = 'http://yunlu.jackqth.com'; //线上
var HTTPUtil = {};

HTTPUtil.post = function (url, formData) {
  // var requestBody = encodeSearchParams(formData);
  if (localStorage.getItem("userId")){
    formData.sysUserId = localStorage.getItem("userId");
  }
  return new promise(function (resolve, reject) {
    fetch(BASE_URL+url, {
      method: 'POST',
      headers: {
        'Accept': 'application/json',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(formData)
    })
        .then(function(response){
      if (response.ok) {
      return response.json();
    } else {
      reject({status: response.status})
    }
  }).then(function (json) {
      if (json.status === '-1'){
        parent.window.location.href = '/login.html'
      }
      return json;
    })
  .then(function(response){
      resolve(response);
  })
  .catch(function(err){
      reject({status: -1});
  })
  })
};
//如需进行第三方地址请求，可以复制上面的方法，去掉BASE_URL

//token参数统一处理方法
function encodeSearchParams(obj) {
  var params = [];
  // var userId = localStorage.getItem('userId');
  // params.push('userId='+ userId);
  Object.keys(obj).forEach(function (key) {
    var value = obj[key];
    if (typeof value === 'undefined') {
      value = ''
    }
    params.push([key, encodeURIComponent(value)].join('='))
  });

  return params.join('&')
}

//ES5 promise对象实现，如需兼容不支持ES6的浏览器，可以进行在线转译
promise = function (fn) {
  this.value = ''; // 保存异步方法的结果
  this.status = 'pending'; // promise 状态
  this.resolveFn = []; // 保存resolve时的回调方法
  this.rejectFn = []; // 保存出错时的回调方法

  function resolve(val) {
    this.value = val;
    this.status = 'resolved';

    // 状态变化时，通知被观察者执行回调函数
    if (this.resolveFn[0]) {
      this.resolveFn[0](val);
    }
  }

  function reject(err) {
    this.value = err;
    this.status = 'rejected';

    if (this.rejectFn[0]) {
      this.rejectFn[0](err);
    }
  }


  try {
    // 采用回调方式保证promise的结果会在主进程执行完后返回
    setTimeout(fn, 0, resolve.bind(this), reject.bind(this))
  } catch (err) {
    setTimeout(reject, 0, err);
  }
};
promise.resolve = function (result) {
  // 直接返回一个resolve状态的promise
  return new promise(function (resolve) {
    resolve(result)
  })
};
promise.reject = function (err) {
  // 直接返回一个reject状态的promise
  return new promise(function (resolve, reject) {
    reject(err)
  })
};

promise.prototype = {
  //then是最复杂的方法，promise不同的状态下有不同的处理方式
  then(resolveFn, rejectFn) {
    var $this = this;

    // 如果then没有传值，则直接返回promise实例本身
    if (!(resolveFn instanceof Function) && !(rejectFn instanceof Function)) {
      return this;
    }
    if (this.status === 'pending') {
      // return 一个promise达到链式调用的效果
      return new promise(function (resolve, reject) {
        if (resolveFn instanceof Function) {
          // 关键点  将事件注册到观察者，形成一条观察者链
          $this.resolveFn.push(function (result) {
            try {
              var a = resolveFn(result);
              // 如果返回结果是一个promise，那么将这个promise的结果注入到返回的promise中
              if (a instanceof promise) {
                a.then(function (result) {
                  resolve(result)
                })
              } else {
                resolve(a);
              }
            } catch (err) {
              reject(err);
            }
          });
        }
        if (rejectFn instanceof Function) {
          $this.rejectFn.push(function (err) {
            try {
              var a = rejectFn(err);
              // 如果返回结果是一个promise，那么将这个promise的结果注入到返回的promise中
              if (a instanceof promise) {
                a.then(function (result) {
                  reject(result)
                })
              } else {
                reject(a);
              }
            } catch (err) {
              reject(err);
            }
          });
        } else {
          $this.rejectFn.push(reject)
        }
      })
    }
    if (this.status === 'resolved') {
      // 校验传入回调是否合法，不合法则不做操作，返回实例本身
      if (resolveFn instanceof Function) {
        try {
          var a = resolveFn($this.value);
          if (a instanceof promise) {
            return a;
          } else {
            return promise.resolve(a);
          }
        } catch (err) {
          return promise.reject(err);
        }
      } else {
        return this;
      }

    }
    if (this.status === 'rejected') {
      if (rejectFn instanceof Function) {
        try{
          var a = rejectFn(this.value);
          if (a instanceof promise) {
            return a;
          } else {
            return promise.resolve(a);
          }
        }catch(err){
          return promise.reject(err)
        }

      } else {
        return this;
      }
    }
  },
  catch(fn) {
    this.then(null,fn);
  }
};

//请求参数统一处理方法
function getUrlParam(name) {
  var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)"); //构造一个含有目标参数的正则表达式对象
  var r = window.location.search.substr(1).match(reg);  //匹配目标参数
  if (r != null){
    return decodeURIComponent(r[2]);
  }
  return null; //返回参数值
}
